/*
 * File:   PalabraAleatoria.cpp
 * Author: root
 *
 * Created on September 15, 2012, 7:23 PM
 */

#include "PalabraAleatoria.h"
#include<cstring>
#include"ConversorCadena.h"

using std::ofstream;
using std::ifstream;

void PalabraAleatoria::setPalabra(char* p){
    if(!p)
        return;

    const unsigned int TAM_P= strlen(p);
    if(TAM_P>TAM_PALABRA)
        return;
    strcpy(palabra,p);
}//setPalabra

char* PalabraAleatoria::getPalabra(){
    return palabra;
}//getPalabra

void PalabraAleatoria::setIdentificador(unsigned long id){
    if(!id)
        return;

    identificador= id;
}//setIdentificador

unsigned long PalabraAleatoria::getIdentificador() const {
    return identificador;
}//getIdentificador

unsigned int PalabraAleatoria::getLongitudPalabra(){
    if(!palabra)
        return 0;
    return strlen(palabra);
}//getLongitudPalabra

bool PalabraAleatoria::operator <(const PalabraAleatoria& pa){
    if(this->identificador < pa.identificador)
        return true;
    if(this->identificador > pa.identificador)
        return false;

    const int COMP_PALABRAS= strcmp(this->palabra,pa.palabra);
    if(COMP_PALABRAS<= 0 )
        return true;
    //claves y palabras son iguales, retorna true considero <=

    return false;
}//<


bool PalabraAleatoria::operator >(const PalabraAleatoria& pa){
    return ( !( (*this)<pa ) );
}// >

int PalabraAleatoria::guardar(char* direccionArchivo){
    if(!direccionArchivo)
        return DIR_ERRONEA;

    ofstream salida(direccionArchivo,ofstream::app);
    if(!salida.is_open())
        return ARCH_INVALIDO;

    salida.write((char*)this,TAM_REGISTRO);
    salida.close();
    return EXITO;

}//guardar

int PalabraAleatoria::guardar(ofstream* salida){
	if(!salida->is_open())
		return this->ARCH_INVALIDO;

	salida->write((char*)this,this->TAM_REGISTRO);
	return this->EXITO;
}

int PalabraAleatoria::guardarComoTexto(ofstream* salida){
	if(!salida->is_open())
		return this->ARCH_INVALIDO;

	const unsigned short LONGITUD_ID_STRING= 9;
	ConversorCadena CONVERSOR;
	char *idString= CONVERSOR.convertir(this->identificador,LONGITUD_ID_STRING);
	const unsigned short LONGITUD_ACTUAL= strlen(idString);
	const unsigned short INICIO_PALABRA= 11;
	const unsigned short ESPACIOS_LIBRES= INICIO_PALABRA - LONGITUD_ACTUAL;
	*salida<<idString;
	//inserto espacios en blanco tal que la palabra inicie en la posicion 11
	for(int i= 0;i<ESPACIOS_LIBRES; i++)
		*salida<<(char)32;
	*salida<<this->palabra;
	//inserto caracter de fin de linea
	*salida<<'\n';

	return this->EXITO;
}

PalabraAleatoria::PalabraAleatoria(char* p, unsigned long id){
    setPalabra(p);
    setIdentificador(id);
}//constructor

PalabraAleatoria::PalabraAleatoria(const PalabraAleatoria& pa){
    if(pa.palabra)
        strcpy(this->palabra,pa.palabra);

    this->identificador= pa.identificador;
}//constructor

//------------------------

int guardarPalabrasAleatorias(PalabraAleatoria* palabrasAleatorias
,unsigned int cantidad,char* direccionArchivo,MODO_GUARDADO modo){
    if(!direccionArchivo)
        return PalabraAleatoria::DIR_ERRONEA;

    ofstream* salida;
    switch(modo){
        case SOBREESCRIBIR:
            salida= new ofstream(direccionArchivo,ofstream::binary);
            break;
        case AGREGAR:
            salida= new ofstream(direccionArchivo,ofstream::app);
            break;
    }//switch

    if(!salida->is_open())
        return PalabraAleatoria::ARCH_INVALIDO;

    salida->write((char*)palabrasAleatorias,cantidad*PalabraAleatoria::TAM_REGISTRO);
    salida->close();

    delete salida;

    return PalabraAleatoria::EXITO;
}//guardarPalabrasAleatorias

PalabraAleatoria::PalabraAleatoria(){
    strcpy(this->palabra,"***");
    // Hago que el identificador sea por defecto un numero imposible
    this->identificador = PalabraAleatoria::MAXIMO_IMPOSIBLE();
}//constructor


// Carga una palabra desde el archivo
bool PalabraAleatoria::cargarPalabra(std::ifstream& fin){
	if (!fin.is_open()){
		return false;
	}

	// Perdon, esto es horrible , pero me contaron que funciona
	PalabraAleatoria* p = new PalabraAleatoria();
	fin.read(reinterpret_cast<char*>(p), sizeof(PalabraAleatoria));

	this->identificador = p->getIdentificador();
	strcpy(this->palabra, p->getPalabra());

	delete p;
	return true;
}
